CPU: 8-bit (Similar to the Z80 processor.) at 4.194304 MHz for 'compatibility mode', 8.388MHz GBC Gameboy Color Mode
Main RAM: 8K Byte
Video RAM: 8K Byte
ROM: 256kBit, 512kBit, 1MBit, 2MBit and 4MBit up to 16 MBit (32kB,64kB, 128kB, 256kB, and 512kB up to 2MB)
Screen Size: 6.6 cm (2.6 inches)
Resolution: Reflective LCD at 160x144 pixels (20x18 tiles - 1 Tile being defined as 8x8 pixels)
Colour: 56 Colours at one time from 32,768 (this comes from the 8 pallettes and 4 colours for the background (8x4 = 32) and the 8 pallettes and 3 colours (since 1 of them is transparent) for the sprites (8x3 = 24) so 32 + 24 = 56).
Max # of sprites: 40
Max # sprites/line: 10
Max sprite size: 8x16
Min sprite size: 8x8
Horiz Sync: 9198 KHz (9420 KHz for SGB)
Vert Sync: 59.73 Hz (61.17 Hz for SGB)
Sound: 4 channels with stereo sound

Interrupts

Let's first talk about interrupts. In case you've forgotten, an interrupt is an event or signal that essentially interrupts whatever code is running (in the 209 course you guys are doing, you'll soon be talking about signals, which are just software interrupts). Interrupts are important because they can provide some sort of timing mechanism, or tell us when some hardware function has finished. For example, in our gameboy programming, we'll want to update the graphics on screen after the LCD is finished refreshing (essentially after its vertical blank). What we do is when we code our game, we define interrupt handlers to specific interrups - they are essentially functions that get called when the interrupt occurs. So, when we're in our game loop, say updating coordinate positions and the vblank interrupt occurs, our handler will be called and do its thing (i.e. redraw the sprites) and when its done we'll go right back to where we left off in our code. The good thing to note is that the gameboy has only five interrupt signals.

1. V-Blank - This interrupt can be generated when the LCD has drawn the last line on the screen and gone into the vertical blanking period, approximately 59.7 times a second. During this period video hardware is not using video ram so it may be freely accessed.
   This period lasts approximately 1.1 milliseconds.
2. LCDC - This interrupt can be generated by the LCD controller chip on various conditions, the most commonly used being the LYC condition, which occurs when the LCD begins to draw a certain scanline. The scanline it generates an interrupt on is selectable. (This can be used for special effects - but we probably won't be using it at all).
3. Timer - The system timer can be set to count at specified frequencies, and will increment a count register. When this register overflows, an interrupt is generated. One of its uses is for sound playback.
4. Serial - This interrupt occurs when a serial transfer has completed on the game link port (we'll never use this).
5. Joypad - This interrupt occurs on a transition of any of the keypad input lines from high to low. Due to the fact that keypad "bounce"* is virtually always present, software should expect this interrupt to occur one or more times for every button press and one or more times for every button release (I'm not sure when this is used - maybe for some very sensitive gameplay I suppose. We'll be using the regular joypad function).
   

Graphics

The Gameboy Color doesn't use APA (all points accessable) graphics such as your computer uses. Instead it uses tiles to draw everything. While this has certain advantages, it also makes simple things such as drawing a line really difficult. The Gameboy Color uses 8x8 pixel tiles to create the background. The Gameboy Color's screen has a resolution of 20x18 tiles or 160x144 pixels. Inside its VRAM, in an area called the Background Tile Map, it stores 32x32 tiles or 256x256 pixels. So there is essentially a virtual screen of 16 extra tiles horizontally and 14 tiles vertically. This is useful for games that scroll the background. The Gameboy Color can display 256 unique tiles on the screen at one time. It has an additional VRAM bank to display an additional 256 tiles, although this kills any chance of backwards compatability with the original Gameboy. (However, it is the case that essentially all 2D games use tiles - even arcade games like Street Fighter II). Sprites are tiles independant of the background. These are used for things such as the main character and badguys. The Gameboy Color can display either 8x8 or 8x16 pixels per tile. It can display 40 sprites simultaniously. One of its main drawbacks is that it can only display 10 sprites per horizontal line. The Gameboy Color features a few hardware sprite manipulations. While it does not feature resizing the sprites or more useful things, you can flip the horizontal and vertical axis on each sprite. This is useful to make a character walk in 2 directions without needing to load a new tile into the sprite. The Gameboy Color can hold 256 8x8 pixel tiles or 128 8x16 pixel tiles into sprite ram. This is useful since it takes alot less computing power to change which ram location to display the tile than to load a unique tile into its place. Notice that there are only two layers on the GBC; the background and the window. The window is a nontransparent layer that can be applied on top of the background. It does not use its own palettes or tiles, but rather shares them with the background's. The window is useful for things such as pop-up maps, status bars that don't scroll with the background, and many other uses.

To solidify everything, let's say that Tile data is stored in VRAM and numbered 0 -127. Now a map is simply a 2D array whose entries are just the array indices of each tile to be placed on a certain area of the LCD, 0-127 in this case. So, the map area is a 32x32 byte array (1024 bytes) that makes up the Background Map, or BGMAP for short. The way the LCD draws a screen is this: it takes the byte value in the map area, and gets the corressponding tile from the tile set, and draws the 8x8 tile where it got the map byte from.

Now, the Sprite area of VRAM is divided into 40 blocks of 4-bytes (where each 4-byte block defines a sprite, thus allowing only 40 sprites on the screen at once). The 4 bytes are laid out thus

ROMS

The ROMs we will compile represent a gameboy game cartridge (i.e. solid state chip that encodes data without changing). Cartridges come in varying sizes from 256kb to 16Mb (the writeable cartridge I have is 16Mb). The GBC can read these bigger cartridges through subtle trickery. What it amounts to is this; the GBC can only "see" a 256Kbit (32KByte) cartridge. This basic cartridge can be subdivided into two 16KByte pieces. The lower 16KByte piece is fixed, while the upper 16KByte piece is variable. What the gameboy does is look through a window 16KByte wide, and keeps on sliding it over to see more data. These 16KByte pieces are called banks. We can have up to 127 banks (for a 16Mbit cart). As you might have guessed, it's beneficial (rather, mandatory) that we split our code amongst these banks. Also, we have to switch to the proper bank manually, since it's not automatic.
                                         
So, we manually tell the gameboy which bank to switch to, and the gameboy in turn envokes the memory bank controller (MBC) on the cartridge. There were two major MBCs made for gb carts: MBC1 and MBC5 other minor ones were MBC2 and MBC3.

First of all note that the GBC uses an 8 bit CPU but its address bus in 16 bits. What this means is that it can address a whopping 64KB of memory. To be painfully precise, that means it can address 0000000000000000 to 1111111111111111, or in hexadecimal (base 16) $0000 to $FFFF (or otherwise denoted by 0x0000 to 0xFFFF). Here is a map of all of gameboy memory so you know what's going on inside.

The GameBoy has instructions & registers similar to the Intel 8080, Intel 8085, & Zilog Z80 microprocessors. It has eight 8-bit general purpose registers A,B,C,D,E,F,H,L and two 16-bit registers SP & PC. Some instructions, however, allow you to use the registers A,B,C,D,E,H, & L as 16-bit registers by pairing them up in the following manner: AF,BC,DE, & HL. The PC, or Program Counter, register points to the next instruction to be executed in the GameBoy memory. The SP, or Stack Pointer, register points to the current stack position. F is the Flag Register and contains the following flags:

• Zero Flag (Z) - This bit is set when the result of a math operation is zero or two values match when using the CP instruction.
• Subtract Flag (N) - This bit is set if a subtraction was performed in the last math instruction.
• Half Carry Flag (H) - This bit is set if a carry occurred from the lower nibble in the last math operation.
• Carry Flag (C) - This bit is set if a carry occurred from the last math operation or if register A is the smaller value when executing the CP instruction.

The GBC also has, in the address range $FF00-$FF7F, memory mapped I/O registers which control all aspects of gameboy hardware: the LCD, speaker, joypad, etc.

Don't be alarmed by all this information. It's mostly there just as reference. You should have mastered the ideas presented in "Basic Concepts" because these are needed to program this system. Also, you should have a general knowledge of the memory map. The I/O Register table is mostly here for completeness. However, also be aware that we need to know some of the I/O registers to properly set up windows and backgrounds (yes we can directly manipulate the registers in GBDK via ANDing and ORing bitmasks to the registers using the & and | operator). Pay special attention to the LCDC register as this is the key to controlling the LCD.

Well, this is almost all the information that defines a gameboy. It's definitely enough for us to write a game. Mostly, this information is essential to assembly programmers (and I don't think we'll be doing any ASM coding, but I could be wrong). However, if you want the technical reference document for the gameboy consult the so-called PanDoc available here. It is the de facto standard for gameboy internals. Well, that's enough of hardware. On to coding.